package com.tx.java8.stream;

import com.tx.java8.domain.Employee;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

/**
 * 流式操作中的中间操作
 */
@SpringBootTest
public class StreamTest2 {
    List<Employee> employees = Arrays.asList(
            new Employee("adeep",1,99999.99),
            new Employee("mercury",15,50000),
            new Employee("张三",30,1200),
            new Employee("张三2号",30,1100),
            new Employee("李四",35,6500),
            new Employee("王五",50,7000),
            new Employee("王五",50,7000),
            new Employee("王五2",50,7000)
    );

    /**
     * 筛选和切片
     *      filter
     *      limit
     *      skip
     *      distinct
     */
    //filter
    @Test
    public void test1(){
        employees.stream()
                .filter((e)->e.getAge() <= 15)
                .forEach(System.out::println);
    }
    //limit
    @Test
    public void test2(){
        employees.stream()
                .filter((e)->e.getAge() > 15)
                .limit(2)
                .forEach(System.out::println);
    }
    //skip:抛掉前两个符合过滤条件的数据
    @Test
    public void test3(){
        employees.stream()
                .filter((e) -> e.getAge() > 15)
                .skip(2)
                .forEach(System.out::println);
    }
    //distinct:判断相似的规则是hashCode和equal方法
    @Test
    public void test4(){
        employees.stream()
                .distinct()
                .forEach(System.out::println);
    }

    /**
     * 映射：
     *      map
     *      flatmap
     */
    //map
    @Test
    public void test5(){
        employees.stream()
                .map(Employee::getName) //类似于  (employee)->return employee.getName()  --然后相当于是传了参数，参数作为调用者，所以可以用方法引用
                .forEach(System.out::println);
    }

    //flatmap
    @Test
    public void test6(){
        //map和flatmap的区别
        List<String> list = Arrays.asList("aaaa","bbbb","ccccc","ddddddd");
        //list.stream()得到Stream<String> 再每个遍历string,map中getStream和function的方法一致（str->getStream,即是字符串转换成流），所以不会报错。
        // 由于map返回的本来就是流，里面转换的对象也是流，所以就是流中流
        Stream<Stream<Character>> stream = list.stream().map(StreamTest2::getStream);
        stream.forEach((s1)->{
            s1.forEach(System.out::println);
        });

        System.out.println("-------------------------------");
        /**
         * flatmap
        **/
        Stream<Character> stream1 = list.stream().flatMap(StreamTest2::getStream);
        stream1.forEach(System.out::println);
    }

    //把字符串转换成stream
    public static Stream<Character> getStream(String str){
        List<Character> list = new ArrayList<>();
        for(Character c : str.toCharArray()){
            list.add(c);
        }
        return list.stream();
    }

    /**
     * 排序：
     *  sorted() 自然排序 (Comparable--compareTo)
     *  sorted(Comparator)  --定制排序
    **/
    @Test
    public void test7(){
        List<String> list = Arrays.asList("eeeee","aaaa","bbbb","ccccc","ddddddd");
        //sorted
        //根据的是Comparable中的compareTo方法来排序的
        list.stream()
                .sorted()
                .forEach(System.out::println);

        //sorted(Comparator com)
        employees.stream()
                .sorted((e1,e2)->{
                    if(e1.getAge() == e2.getAge()){
                        return e1.getName().compareTo(e2.getName());
                    }else{
                        return e1.getAge() - e2.getAge();
                    }
                }).forEach(System.out::println);
    }
}